import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'dart:developer' as developer;

// 🔥 导入MessageChatController，用于获取聊天状态
import '../../pages/message/message_chat/controller.dart';
import 'background_notification_helper.dart';

/// 通知队列项
class NotificationQueueItem {
  final String senderUserId; // 手机号（用于融云IM）
  final int? friendId; // 🔥 数据库ID（用于路由跳转）
  final String senderName;
  final String senderAvatar;
  final String messageContent;
  final DateTime timestamp;
  final String? messageId; // 🔥 消息ID，用于去重

  NotificationQueueItem({
    required this.senderUserId,
    this.friendId, // 🔥 新增
    required this.senderName,
    required this.senderAvatar,
    required this.messageContent,
    DateTime? timestamp,
    this.messageId,
  }) : timestamp = timestamp ?? DateTime.now();
}

/// 智能通知工具类
///
/// 🎯 核心功能：
/// - 根据当前页面状态决定显示方式
/// - 聊天界面直接显示 vs 顶部弹窗通知
/// - 消息去重和队列管理
///
/// 📋 显示规则：
/// - 正在与发送者聊天 → ❌ 不弹框（消息直接显示）
/// - 在其他页面 → ✅ 显示顶部弹框
/// - App在后台 → ✅ 使用极光推送（由其他模块处理）
class SmartNotificationUtil {
  static SmartNotificationUtil? _instance;
  static SmartNotificationUtil get instance =>
      _instance ??= SmartNotificationUtil._();

  SmartNotificationUtil._();

  // Flutter本地通知插件实例
  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
      FlutterLocalNotificationsPlugin();

  // 当前是否正在显示顶部通知
  final RxBool _isShowingTopNotification = false.obs;

  // 🔥 通知队列 - 跟踪排队等待显示的通知
  final List<NotificationQueueItem> _notificationQueue = [];

  // 🔥 正在处理通知的标记，避免重复处理
  bool _isProcessingQueue = false;

  // 🔥 已处理的消息ID缓存，防止重复通知同一条消息
  final Set<String> _processedMessageIds = <String>{};

  // 🔥 企业级功能：当前正在显示的通知用户ID
  String? _currentDisplayingUserId;

  // 🔥 企业级功能：用户消息缓存（用于合并显示）
  final Map<String, List<String>> _userMessagesCache = {};

  // 🔥 企业级功能：用户消息真实数量计数（用于显示）
  final Map<String, int> _userMessageCount = {};

  // 🔥 企业级功能：通知显示取消器
  Function? _currentNotificationDismisser;

  /// 初始化通知系统
  Future<void> initialize() async {
    try {
      developer.log('🔔 =============== 初始化智能通知系统 ===============');

      // Android通知设置
      const AndroidInitializationSettings initializationSettingsAndroid =
          AndroidInitializationSettings('@mipmap/ic_launcher');

      // iOS通知设置
      const DarwinInitializationSettings initializationSettingsDarwin =
          DarwinInitializationSettings(
            requestAlertPermission: true,
            requestBadgePermission: true,
            requestSoundPermission: true,
          );

      const InitializationSettings initializationSettings =
          InitializationSettings(
            android: initializationSettingsAndroid,
            iOS: initializationSettingsDarwin,
          );

      await _flutterLocalNotificationsPlugin.initialize(
        initializationSettings,
        onDidReceiveNotificationResponse: _onNotificationTapped,
      );

      developer.log('✅ 智能通知系统初始化完成');
    } catch (e) {
      developer.log('💥 智能通知系统初始化失败: $e');
    }
  }

  /// 处理通知点击事件
  void _onNotificationTapped(NotificationResponse notificationResponse) {
    developer.log('📱 用户点击了通知: ${notificationResponse.payload}');
    // 可以在这里处理点击通知后的跳转逻辑
  }

  /// 🔥 智能处理消息通知
  ///
  /// 核心逻辑：
  /// 1. 消息去重检查
  /// 2. 判断是否在聊天页面
  /// 3. 添加到队列或直接显示
  ///
  /// [senderUserId] 发送者用户ID（手机号）
  /// [friendId] 发送者数据库ID（用于路由跳转）
  /// [senderName] 发送者昵称
  /// [senderAvatar] 发送者头像URL
  /// [messageContent] 消息内容
  /// [currentChatUserId] 当前聊天页面的用户ID（如果在聊天页面）
  /// [messageId] 消息ID，用于去重（可选）
  Future<void> handleMessageNotification({
    required String senderUserId,
    int? friendId, // 🔥 新增：数据库ID
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    String? currentChatUserId,
    String? messageId,
  }) async {
    try {
      developer.log('🔔 =============== 智能消息通知处理 ===============');
      developer.log('📨 消息发送者: $senderName (ID: $senderUserId)');
      developer.log('💬 消息内容: $messageContent');
      developer.log('📱 当前聊天对象ID: $currentChatUserId');
      developer.log('🆔 消息ID: ${messageId ?? "无ID"}');

      // 🔥 1. 消息去重检查
      if (messageId != null && messageId.isNotEmpty) {
        if (_processedMessageIds.contains(messageId)) {
          developer.log('✋ 消息ID: $messageId 已处理过，跳过重复通知');
          return;
        }

        // 记录该消息ID为已处理
        _processedMessageIds.add(messageId);
        developer.log('✅ 消息ID已记录为已处理: $messageId');

        // 🔥 限制缓存大小，防止内存泄漏（保留最近1000条）
        if (_processedMessageIds.length > 1000) {
          final excessCount = _processedMessageIds.length - 1000;
          final oldIds = _processedMessageIds.take(excessCount).toList();
          for (final oldId in oldIds) {
            _processedMessageIds.remove(oldId);
          }
          developer.log('🗑️ 清理过旧的消息ID缓存: $excessCount个');
        }
      }

      // 🔥 2. 过滤活动审核结果消息（不显示通知）
      if (senderName == '系统通知' &&
          (messageContent.contains('申请参加的活动') &&
              (messageContent.contains('审核已通过') ||
                  messageContent.contains('审核已被拒绝')))) {
        developer.log('🔕 活动审核结果消息，不显示通知弹窗');
        developer.log('   发送者: $senderName');
        developer.log('   内容: $messageContent');
        return;
      }

      // 🔥 3. 获取当前路由信息
      final currentRoute = Get.currentRoute;
      developer.log('🌍 当前路由: $currentRoute');

      // 🔥 4. 检查是否在聊天页面且是同一个用户
      final isInChatWithSameUser = _isInChatPageWithUser(
        currentRoute,
        currentChatUserId,
        senderUserId,
      );

      developer.log('👥 是否在与发送者聊天: $isInChatWithSameUser');

      if (isInChatWithSameUser) {
        developer.log('✅ 当前正在与发送者聊天，消息将直接显示在聊天界面');
        // 🔥 清除该用户的所有排队通知
        _clearUserNotificationsFromQueue(senderUserId);
        return;
      }

      // 🔥 5. 企业级功能：检查是否是同一个用户的消息
      if (_currentDisplayingUserId == senderUserId &&
          _isShowingTopNotification.value) {
        developer.log('🔄 同一用户的新消息，准备更新通知');

        // 添加消息到缓存
        _addMessageToCache(senderUserId, messageContent);

        // 关闭当前通知，准备显示更新后的通知
        if (_currentNotificationDismisser != null) {
          _currentNotificationDismisser!();
          _currentNotificationDismisser = null;
        }

        // 等待当前通知关闭
        await Future.delayed(const Duration(milliseconds: 150));

        // 显示合并后的通知
        await _showMergedNotification(
          senderUserId: senderUserId,
          friendId: friendId, // 🔥 传递friendId
          senderName: senderName,
          senderAvatar: senderAvatar,
        );

        return;
      }

      // 🔥 6. 企业级优化：清空该用户在队列中的旧通知
      // 原因：新消息到来时，队列中的旧消息应该被丢弃，统一合并显示
      _clearUserNotificationsFromQueue(senderUserId);
      developer.log('🧹 已清空用户 $senderUserId 在队列中的旧通知');

      // 🔥 7. 添加通知到队列
      developer.log('🔔 添加通知到队列');

      // 添加消息到缓存
      _addMessageToCache(senderUserId, messageContent);

      _addNotificationToQueue(
        senderUserId: senderUserId,
        friendId: friendId, // 🔥 传递friendId
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageContent: messageContent,
        messageId: messageId,
      );

      developer.log('📊 队列长度: ${_notificationQueue.length}');

      // 🔥 8. 处理通知队列
      _processNotificationQueue();
    } catch (e) {
      developer.log('💥 智能消息通知处理异常: $e');
    }
  }

  /// 🔥 检查是否在聊天页面且是同一个用户
  bool _isInChatPageWithUser(
    String currentRoute,
    String? currentChatUserId,
    String senderUserId,
  ) {
    // 检查是否在聊天页面
    final isInChatPage =
        currentRoute.contains('message_chat') ||
        currentRoute.contains('MessageChat');

    if (!isInChatPage) {
      developer.log('📱 不在聊天页面，需要显示通知');
      return false;
    }

    developer.log('📱 正在聊天页面，检查是否与发送者聊天...');

    // 🔥 如果currentChatUserId为空，尝试从控制器中获取
    String? finalChatUserId = currentChatUserId;

    if (finalChatUserId == null) {
      developer.log('📱 当前聊天用户ID为空，尝试从MessageChatController获取...');

      try {
        // 🔥 尝试获取MessageChatController（使用手机号）
        if (Get.isRegistered<MessageChatController>()) {
          final controller = Get.find<MessageChatController>();
          finalChatUserId =
              controller.friendPhone; // 🔥 使用friendPhone而不是friendId
          if (finalChatUserId != null) {
            developer.log('📱 从控制器获取到聊天用户手机号: $finalChatUserId');
          }
        }

        // 如果仍未获取到，尝试从路由参数获取
        if (finalChatUserId == null) {
          final args = Get.arguments;
          if (args is Map<String, dynamic> && args['friendPhone'] != null) {
            finalChatUserId = args['friendPhone']
                ?.toString(); // 🔥 使用friendPhone
            developer.log('📱 从路由参数获取到用户手机号: $finalChatUserId');
          }
        }
      } catch (e) {
        developer.log('📱 获取聊天用户手机号过程异常: $e');
      }
    }

    // 最终判断
    if (finalChatUserId == null) {
      developer.log('📱 无法确定当前聊天用户ID，默认显示通知');
      return false;
    }

    if (finalChatUserId != senderUserId) {
      developer.log('📱 正在与其他用户聊天 (当前: $finalChatUserId, 发送者: $senderUserId)');
      return false;
    }

    developer.log('📱 正在与发送者聊天，消息直接显示');
    return true;
  }

  /// 🔥 显示顶部弹窗通知
  Future<void> _showTopBannerNotification({
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    required String senderUserId,
    int? friendId, // 🔥 新增：用于跳转
  }) async {
    developer.log('🎭 =============== 显示顶部弹窗通知 ===============');
    developer.log('👤 发送者: $senderName');
    developer.log('💬 消息内容: $messageContent');

    // 如果已经在显示通知，先关闭之前的
    if (_isShowingTopNotification.value) {
      developer.log('⚠️ 已有通知在显示，先关闭之前的通知');
      Get.back();
      await Future.delayed(const Duration(milliseconds: 100));
    }

    _isShowingTopNotification.value = true;
    _currentDisplayingUserId = senderUserId; // 🔥 记录当前显示的用户ID

    // 显示顶部弹窗
    Get.snackbar(
      '', // 空标题，使用自定义内容
      '',
      snackPosition: SnackPosition.TOP,
      backgroundColor: Colors.white,
      duration: const Duration(milliseconds: 3000), // 🔥 3秒自动消失（企业级优化）
      margin: const EdgeInsets.fromLTRB(8, 25, 8, 0),
      borderRadius: 12,
      boxShadows: [
        BoxShadow(
          color: Colors.black.withOpacity(0.12),
          blurRadius: 8,
          offset: const Offset(0, 2),
        ),
      ],
      titleText: const SizedBox.shrink(),
      messageText: _buildNotificationContent(
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageContent: messageContent,
      ),
      onTap: (_) {
        // 🔥 点击通知跳转到聊天页面
        developer.log('💬 用户点击了通知，准备跳转到聊天页面');
        _navigateToChatPage(
          friendId: friendId,
          friendPhone: senderUserId,
          friendName: senderName,
          friendAvatar: senderAvatar,
        );
        _dismissCurrentNotification(senderUserId);
      },
      isDismissible: true,
      dismissDirection: DismissDirection.horizontal,
      forwardAnimationCurve: Curves.easeOutBack,
      reverseAnimationCurve: Curves.easeInBack,
      animationDuration: const Duration(milliseconds: 400),
    );

    // 🔥 保存通知关闭器
    _currentNotificationDismisser = () {
      if (Get.isSnackbarOpen == true) {
        Get.back();
      }
    };

    developer.log('📢 GetX Snackbar已显示');

    // 震动反馈
    try {
      HapticFeedback.lightImpact();
      developer.log('📳 震动反馈已触发');
    } catch (e) {
      developer.log('💥 震动反馈异常: $e');
    }

    // 🔥 3秒后自动清理状态
    Future.delayed(const Duration(milliseconds: 3000), () {
      if (_currentDisplayingUserId == senderUserId) {
        _isShowingTopNotification.value = false;
        _currentDisplayingUserId = null;
        _currentNotificationDismisser = null;
        developer.log('⏰ 通知显示状态已重置');
      }
    });

    developer.log('🎉 =============== 顶部弹窗通知设置完成 ===============');
  }

  /// 🔥 构建通知内容UI
  Widget _buildNotificationContent({
    required String senderName,
    required String senderAvatar,
    required String messageContent,
  }) {
    return Container(
      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
      child: Row(
        children: [
          // 发送者头像
          Container(
            width: 40,
            height: 40,
            decoration: BoxDecoration(
              shape: BoxShape.circle,
              color: Colors.grey[300],
              image: (senderAvatar.isNotEmpty)
                  ? DecorationImage(
                      image: NetworkImage(senderAvatar),
                      fit: BoxFit.cover,
                      onError: (exception, stackTrace) {
                        developer.log('❌ 头像加载失败: $exception');
                      },
                    )
                  : null,
            ),
            child: (senderAvatar.isEmpty)
                ? const Icon(Icons.person, color: Colors.grey, size: 20)
                : null,
          ),

          const SizedBox(width: 10),

          // 消息内容
          Expanded(
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              mainAxisSize: MainAxisSize.min,
              children: [
                // 发送者昵称
                Text(
                  senderName,
                  style: const TextStyle(
                    fontSize: 14,
                    fontWeight: FontWeight.w600,
                    color: Colors.black87,
                  ),
                  maxLines: 1,
                  overflow: TextOverflow.ellipsis,
                ),

                const SizedBox(height: 3),

                // 消息内容
                Text(
                  messageContent,
                  style: const TextStyle(
                    fontSize: 13,
                    color: Colors.black54,
                    height: 1.2,
                  ),
                  maxLines: 1,
                  overflow: TextOverflow.ellipsis,
                ),
              ],
            ),
          ),

          const SizedBox(width: 8),
        ],
      ),
    );
  }

  /// 🔥 添加通知到队列
  void _addNotificationToQueue({
    required String senderUserId,
    int? friendId, // 🔥 新增
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    String? messageId,
  }) {
    final notificationItem = NotificationQueueItem(
      senderUserId: senderUserId,
      friendId: friendId, // 🔥 传递friendId
      senderName: senderName,
      senderAvatar: senderAvatar,
      messageContent: messageContent,
      messageId: messageId,
    );

    _notificationQueue.add(notificationItem);
    developer.log('📤 通知已添加到队列: $senderName - $messageContent');
  }

  /// 🔥 处理通知队列 - 显示下一个通知
  Future<void> _processNotificationQueue() async {
    developer.log('🔄 开始处理通知队列');
    developer.log(
      '📊 队列状态: 长度=${_notificationQueue.length}, 正在处理=$_isProcessingQueue',
    );

    // 如果已经在处理队列或正在显示通知，则等待
    if (_isProcessingQueue || _isShowingTopNotification.value) {
      developer.log('⏱️ 队列正在处理中，跳过');
      return;
    }

    // 如果队列为空，无需处理
    if (_notificationQueue.isEmpty) {
      developer.log('📭 通知队列为空');
      return;
    }

    _isProcessingQueue = true;

    try {
      // 获取队列中的第一个通知
      final notification = _notificationQueue.removeAt(0);
      developer.log('📢 处理队列通知: ${notification.senderName}');

      // 再次检查用户是否已经在聊天页面
      final currentRoute = Get.currentRoute;
      final isInChatWithSameUser = _isInChatPageWithUser(
        currentRoute,
        null,
        notification.senderUserId,
      );

      if (isInChatWithSameUser) {
        developer.log('❌ 用户已在聊天页面，跳过显示通知');
        _clearUserNotificationsFromQueue(notification.senderUserId);
      } else {
        // 🔥 企业级优化：检查是否有缓存的消息，如果有多条则显示合并通知
        final realMessageCount =
            _userMessageCount[notification.senderUserId] ?? 0;
        final cachedMessages =
            _userMessagesCache[notification.senderUserId] ?? [];

        developer.log(
          '✅ 显示顶部通知（真实消息数：$realMessageCount，缓存数：${cachedMessages.length}）',
        );

        if (realMessageCount > 1) {
          // 有多条消息，显示合并通知
          developer.log('📦 检测到多条消息，显示合并通知');
          await _showMergedNotification(
            senderUserId: notification.senderUserId,
            friendId: notification.friendId, // 🔥 传递friendId
            senderName: notification.senderName,
            senderAvatar: notification.senderAvatar,
          );
        } else {
          // 单条消息，显示普通通知
          developer.log('📨 单条消息，显示普通通知');
          await _showTopBannerNotification(
            senderName: notification.senderName,
            senderAvatar: notification.senderAvatar,
            messageContent: notification.messageContent,
            senderUserId: notification.senderUserId,
            friendId: notification.friendId, // 🔥 传递friendId
          );
        }

        // 等待通知显示完成（3秒 + 100ms缓冲）
        await Future.delayed(const Duration(milliseconds: 3100));

        developer.log('✅ 通知显示完成');
      }

      // 递归处理下一个通知
      if (_notificationQueue.isNotEmpty) {
        developer.log('🔄 继续处理下一个通知 (剩余: ${_notificationQueue.length})');
        Future.microtask(() => _processNotificationQueue());
      } else {
        developer.log('🎉 所有通知处理完成');
      }
    } catch (e) {
      developer.log('💥 处理通知队列异常: $e');
    } finally {
      _isProcessingQueue = false;
      developer.log('🏁 通知队列处理结束');
    }
  }

  /// 🔥 清除特定用户的排队通知
  void _clearUserNotificationsFromQueue(String userId) {
    final beforeCount = _notificationQueue.length;
    _notificationQueue.removeWhere(
      (notification) => notification.senderUserId == userId,
    );
    final afterCount = _notificationQueue.length;
    final removedCount = beforeCount - afterCount;

    if (removedCount > 0) {
      developer.log('🗑️ 已清除用户 $userId 的 $removedCount 条排队通知');
    }
  }

  /// 🔥 企业级功能：添加消息到缓存
  void _addMessageToCache(String userId, String message) {
    // 1. 初始化缓存和计数器
    if (!_userMessagesCache.containsKey(userId)) {
      _userMessagesCache[userId] = [];
      _userMessageCount[userId] = 0;
    }

    // 2. 添加消息到缓存
    _userMessagesCache[userId]!.add(message);

    // 3. 增加真实消息计数
    _userMessageCount[userId] = (_userMessageCount[userId] ?? 0) + 1;

    // 4. 限制缓存大小，保留最近10条消息（用于预览）
    if (_userMessagesCache[userId]!.length > 10) {
      _userMessagesCache[userId] = _userMessagesCache[userId]!.sublist(
        _userMessagesCache[userId]!.length - 10,
      );
    }

    final realCount = _userMessageCount[userId]!;
    final cacheCount = _userMessagesCache[userId]!.length;
    developer.log('📦 消息已添加到缓存: 用户=$userId, 真实数=$realCount, 缓存数=$cacheCount');
  }

  /// 🔥 企业级功能：显示合并后的通知
  Future<void> _showMergedNotification({
    required String senderUserId,
    int? friendId, // 🔥 新增：用于跳转
    required String senderName,
    required String senderAvatar,
  }) async {
    developer.log('🎭 =============== 显示合并通知（企业级） ===============');

    final messages = _userMessagesCache[senderUserId] ?? [];
    final realMessageCount = _userMessageCount[senderUserId] ?? 0;

    if (messages.isEmpty || realMessageCount == 0) {
      developer.log('⚠️ 没有缓存的消息，跳过显示');
      return;
    }

    developer.log('👤 发送者: $senderName');
    developer.log('📦 真实消息数量: $realMessageCount');
    developer.log('📦 缓存消息数量: ${messages.length}');

    // 获取最新的消息内容
    final latestMessage = messages.last;

    // 🔥 构建显示的消息数量标识（超过99显示99+）
    String countLabel;
    if (realMessageCount > 99) {
      countLabel = '99+';
    } else {
      countLabel = '$realMessageCount';
    }

    // 构建显示的消息内容
    final displayContent = realMessageCount > 1
        ? '[$countLabel条消息] $latestMessage'
        : latestMessage;

    developer.log('💬 显示内容: $displayContent');

    _isShowingTopNotification.value = true;
    _currentDisplayingUserId = senderUserId;

    // 显示顶部弹窗
    Get.snackbar(
      '', // 空标题，使用自定义内容
      '',
      snackPosition: SnackPosition.TOP,
      backgroundColor: Colors.white,
      duration: const Duration(milliseconds: 3000),
      margin: const EdgeInsets.fromLTRB(8, 25, 8, 0),
      borderRadius: 12,
      boxShadows: [
        BoxShadow(
          color: Colors.black.withOpacity(0.12),
          blurRadius: 8,
          offset: const Offset(0, 2),
        ),
      ],
      titleText: const SizedBox.shrink(),
      messageText: _buildNotificationContent(
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageContent: displayContent,
      ),
      onTap: (_) {
        // 🔥 点击通知跳转到聊天页面
        developer.log('💬 用户点击了通知，准备跳转到聊天页面');
        _navigateToChatPage(
          friendId: friendId,
          friendPhone: senderUserId,
          friendName: senderName,
          friendAvatar: senderAvatar,
        );
        _dismissCurrentNotification(senderUserId);
      },
      isDismissible: true,
      dismissDirection: DismissDirection.horizontal,
      forwardAnimationCurve: Curves.easeOutBack,
      reverseAnimationCurve: Curves.easeInBack,
      animationDuration: const Duration(milliseconds: 400),
    );

    // 🔥 保存通知关闭器
    _currentNotificationDismisser = () {
      if (Get.isSnackbarOpen == true) {
        Get.back();
      }
    };

    developer.log('📢 GetX Snackbar已显示（合并模式）');

    // 震动反馈
    try {
      HapticFeedback.mediumImpact(); // 使用稍强的震动反馈，表示有多条消息
      developer.log('📳 震动反馈已触发（中等强度）');
    } catch (e) {
      developer.log('💥 震动反馈异常: $e');
    }

    // 3秒后自动清理状态
    Future.delayed(const Duration(milliseconds: 3000), () {
      if (_currentDisplayingUserId == senderUserId) {
        _isShowingTopNotification.value = false;
        _currentDisplayingUserId = null;
        _currentNotificationDismisser = null;
        developer.log('⏰ 通知显示状态已重置（合并模式）');
      }
    });

    developer.log('🎉 =============== 合并通知显示完成 ===============');
  }

  /// 🔥 企业级功能：关闭当前通知
  void _dismissCurrentNotification(String userId) {
    developer.log('🚫 关闭当前通知: $userId');

    if (_currentNotificationDismisser != null) {
      _currentNotificationDismisser!();
      _currentNotificationDismisser = null;
    }

    _isShowingTopNotification.value = false;
    _currentDisplayingUserId = null;
    _clearUserNotificationsFromQueue(userId);

    // 清除该用户的消息缓存和计数
    _userMessagesCache.remove(userId);
    _userMessageCount.remove(userId);

    developer.log('✅ 通知已关闭，缓存和计数已清理');
  }

  /// 🔥 公共方法：清除特定用户的所有通知
  Future<void> clearUserNotifications(String userId) async {
    try {
      developer.log('🧹 清除用户通知: $userId');

      // 清除队列中的通知
      _clearUserNotificationsFromQueue(userId);

      // 清除消息缓存和计数
      _userMessagesCache.remove(userId);
      _userMessageCount.remove(userId);
      await BackgroundNotificationHelper.instance.clearUserNotifications(
        userId,
      );

      // 如果当前正在显示该用户的通知，也关闭
      if (_isShowingTopNotification.value &&
          _currentDisplayingUserId == userId) {
        Get.back();
        _isShowingTopNotification.value = false;
        _currentDisplayingUserId = null;
        _currentNotificationDismisser = null;
        developer.log('❌ 已关闭当前显示的通知');
      }

      developer.log('✅ 用户通知清除完成');
    } catch (e) {
      developer.log('💥 清除用户通知异常: $e');
    }
  }

  /// 清除所有通知
  Future<void> clearAllNotifications() async {
    try {
      await _flutterLocalNotificationsPlugin.cancelAll();
      _notificationQueue.clear();
      _userMessagesCache.clear(); // 🔥 清理消息缓存
      _userMessageCount.clear(); // 🔥 清理消息计数
      _isShowingTopNotification.value = false;
      _currentDisplayingUserId = null;
      _currentNotificationDismisser = null;
      developer.log('✅ 所有通知已清除');
    } catch (e) {
      developer.log('💥 清除通知失败: $e');
    }
  }

  /// 🔥 跳转到聊天页面
  void _navigateToChatPage({
    int? friendId,
    required String friendPhone,
    required String friendName,
    required String friendAvatar,
  }) {
    try {
      developer.log('🚀 跳转到聊天页面');
      developer.log('   好友ID: $friendId');
      developer.log('   好友手机: $friendPhone');
      developer.log('   好友名称: $friendName');

      // 导入RouteNames
      // import '../../common/routers/names.dart';
      Get.toNamed(
        '/message_message_chat', // 使用路由路径
        arguments: {
          'friendId': friendId,
          'friendPhone': friendPhone,
          'friendName': friendName,
          'friendAvatar': friendAvatar,
        },
      );

      developer.log('✅ 路由跳转成功');
    } catch (e) {
      developer.log('💥 跳转到聊天页面失败: $e');
    }
  }
}
